package io.github.biezhi.java8.stream.lesson2;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.*;
import java.util.stream.Collectors;

/*
 * (1) 找出2011年发生的所有交易，并按交易额排序（从低到高）。
 * (2) 交易员都在哪些不同的城市工作过？
 * (3) 查找所有来自于剑桥的交易员，并按姓名排序。
 * (4) 返回所有交易员的姓名字符串，按字母顺序排序。
 * (5) 有没有交易员是在米兰工作的？
 * (6) 打印生活在剑桥的交易员的所有交易额。
 * (7) 所有交易中，最高的交易额是多少？
 * (8) 找到交易额最小的交易。
 *
 */
public class QuizEndNew {
    // 交易员
    @Data
    @AllArgsConstructor
    static class Trader {
        // 姓名
        private String name;
        // 城市
        private String city;
    }

    // 交易
    @Data
    @AllArgsConstructor
    static class Transaction {
        private QuizEnd.Trader trader;
        // 交易年份
        private int    year;
        // 交易额
        private int    value;
    }

    public static void main(String[] args) {
        QuizEnd.Trader raoul = new QuizEnd.Trader("Raoul", "Cambridge");
        QuizEnd.Trader mario = new QuizEnd.Trader("Mario", "Milan");
        QuizEnd.Trader alan = new QuizEnd.Trader("Alan", "Cambridge");
        QuizEnd.Trader brian = new QuizEnd.Trader("Brian", "Cambridge");

        List<QuizEnd.Transaction> transactions = Arrays.asList(
                new QuizEnd.Transaction(brian, 2011, 300),
                new QuizEnd.Transaction(raoul, 2012, 1000),
                new QuizEnd.Transaction(raoul, 2011, 400),
                new QuizEnd.Transaction(mario, 2012, 710),
                new QuizEnd.Transaction(mario, 2012, 700),
                new QuizEnd.Transaction(alan, 2012, 950)
        );

        System.out.println("=========================");
        //01
        transactions.stream()
                .filter(transaction -> transaction.getYear() == 2011)
                .sorted(Comparator.comparing(transaction -> transaction.getValue()))
                .collect(Collectors.toList())
                .forEach(System.out::println);

        System.out.println("=========================");
        // 02
        transactions.stream()
                .map(transaction -> transaction.getTrader())
                .map(trader -> trader.getCity())
                .distinct()
                .collect(Collectors.toList())
                .forEach(System.out::println);

        System.out.println("=========================");
        // 03 查找所有来自于剑桥的交易员，并按姓名排序。
        transactions.stream()
                .map(transaction -> transaction.getTrader())
                .filter(trader -> trader.getCity().equals("Cambridge"))
                .sorted(Comparator.comparing(trader -> trader.getName()))
                .collect(Collectors.toList())
                .forEach(System.out::println);

        System.out.println("=========================");
        // 04 返回所有交易员的姓名字符串，按字母顺序排序。
        List<String> collect = transactions.stream()
                .map(transaction -> transaction.getTrader())
                .map(trader -> trader.getName())
                .sorted(Comparator.naturalOrder())
                .collect(Collectors.toList());
        collect.forEach(System.out::println);

        // 05有没有交易员是在米兰工作的？
        System.out.println("=========================");
        boolean milan = transactions.stream()
                .anyMatch(transaction -> transaction.getTrader().getCity().equals("Milan"));
        System.out.println(milan);

        // 06 打印生活在剑桥的交易员的所有交易额。
        System.out.println("=========================");
        Integer cambridge = transactions.stream()
                .filter(transaction -> transaction.getTrader().getCity().equals("Cambridge"))
                .map(transaction -> transaction.getValue())
                .reduce(0, Integer::sum);
        System.out.println("生活在剑桥的交易员的所有交易额：" + cambridge);

        // 07 所有交易中，最高的交易额是多少？
        System.out.println("=========================");
        Integer max = transactions.stream()
                .map(transaction -> transaction.getValue())
                .reduce(0, Integer::max);
        System.out.println("所有交易中，最高的交易额是多少？" + max);

        // 07 找到交易额最小的交易。
        System.out.println("=========================");
        Optional<Integer> min = transactions.stream()
                .map(transaction -> transaction.getValue())
                .reduce(Integer::min);
        System.out.println("找到交易额最小的交易。" + min);

    }
}
